import javax.swing.plaf.IconUIResource;
import java.util.Random;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: Jared
 * Date: 2022-12-06
 * Time: 15:39
 *
 *  当行、多行、文档注释
 *
 *  任何一行代码，有括号就加上，不要省略
 *
 *
 *
 *  main函数的快捷键 psvm +回车
 *  打印的快捷键 sout + 回车
 */
public class TestDemo {



    /*  方法的重载 overload   */
    /*  条件：1、方法名相同 2、方法的参数列表不同(个数，类型) 3、方法的返回值不做要求*/
    /*  重载会自动识别         */
    public static int add(int a,int b){
        return a+b;
    }
    public  static double add(double a,double b){
        return a+b;
    }
    public static int add(int a,int b,int c){
        return a+b+c;
    }

    public static void main39(String[] args) {
        System.out.println(add(10,20));
        System.out.println(add(10.5,20.5));
        System.out.println(add(10,20,30));
    }

    public static void swap(int a,int b){
        int tmp =a;
        a=b;
        b=tmp;
    }

    public static void login(){
        Scanner scanner = new Scanner(System.in);
        int count =3;
        while (count!=0){
            System.out.println("请输入你的密码：");
            String password=scanner.nextLine();
            if(password.equals("123456")){
                System.out.println("你登陆成功了");
                break;
            }else {
                count--;
                System.out.println("你输错密码了，你还有"+count+"次机会");
            }
        }
    }

    public static void main45(String[] args) {
        login();
    }

    public static void main38(String[] args) {
        int a =10;
        int b=20;
        //在Java里面是拿不到栈上的地址的 swap(&a,&b)错误
        //如果要去做，只能把a和b的值放到堆上，放到堆上的都是对象
        swap(a,b);
        System.out.println(a+" "+b);
    }


    /**
     * 求1-n的和
     * 函数名字必须是小驼峰
     * @param n 代表是输入的一个数字
     * @return 求的和
     */
    public  static int sumAdd(int n){
        int sum = 0;
        for (int i = 0; i <=n ; i++) {
            sum += i;
        }
        return sum;
    }

    /**
     * 方法：和函数是一个意思，功能都是重复使用
     * @param args
     */
    public static void main37(String[] args) {
        int ret = sumAdd(10); //方法的调用 实参传递给形参是按值传递
                                // 实际上，在Java中，只有按值传递
        System.out.println(ret);
        System.out.println(facSum(5));
    }

    /**
     * 求某个数字的阶乘
     * @param n
     * @return
     */
    public static int fac(int n){
        int ret = 1;
        for (int i = 1; i <=n ; i++) {
            ret*=i;
        }
        return ret;
    }

    /**
     * 求n的阶乘的和
     * @param n
     * @return
     */
    public static int facSum(int n){
        int sum =0;
        for (int i = 1; i <= n; i++) {
            sum += fac(i);
        }
        return sum;
    }

    public static void main36(String[] args) {
        int count =0;
        for (int i = 0; i < 101; i++) {
            if(i%10==9){
                count++;
            }
            if(i/10==9){
                count++;
            }
        }
        System.out.println(count);
    }

    public static void main35(String[] args) {
        double sum = 0.0;
        int flag = 1;
        for (int i = 1; i < 101; i++) {
            sum+=1.0/i*flag; //注意这里要给1.0，才能保证出现小数点，否则整数相除后面都是0
            flag = -flag;
        }
        System.out.println(sum);
    }

    /**
     * 辗转相除法求最大公约数
     * @param args
     */
    public static void main34(String[] args) {
        int a = 24;
        int b = 18;
        int c = a%b;
        while (c!=0){
            a = b;
            b = c;
            c = a%b;
        }
        System.out.println("最大公约数是 "+b);
    }

    public static void main33(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i+"*"+j+"="+i*j+" ");
            }
            System.out.println();
        }
    }

    public static void main32(String[] args) {
        for (int year = 1000; year < 2000 ; year++) {
            if(year%4==0&&year%100!=0||year%400==0){
                System.out.println(year+ " 是闰年！");
            }
        }
    }

    public static void main31(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n =scanner.nextInt();
        int i = 2;
        for (; i <= Math.sqrt(n); i++) {
            if(n%i==0){
                System.out.println(n+" 不是素数");
                break;
            }
        }
        if(i>Math.sqrt(n)){
            System.out.println(n+" 是素数！");
        }
    }

    public static void main30(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n =scanner.nextInt();
        if(n<18){
            System.out.println("少年");
        } else if(n>=18&& n<28) {
            System.out.println("青年");
        } else if(n>=29&&n<56){
            System.out.println("中年");
        } else {
            System.out.println("老年");
        }
    }
    public static void main29(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n =scanner.nextInt();
        if(n<18){
            System.out.println("少年");
        } else if(n>=18&& n<28) {
            System.out.println("青年");
        } else if(n>=29&&n<56)
            System.out.println("中年");
    }



    public static void main28(String[] args) {
        Scanner scanner = new Scanner(System.in);

        Random random =new Random();// 默认随机种子是系统时间
        int rand = random.nextInt(100); //[0-100)

        while (true) {
            System.out.println("请输入要输入的数字: (1-100)");
            int n = scanner.nextInt();
            if (n < rand) {
                System.out.println("低了");
            } else if (n > rand) {
                System.out.println("高了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
        scanner.close();
    }
    public static void main27(String[] args) {
        Scanner scanner =new Scanner(System.in);
        while (scanner.hasNextInt()){
            int n =scanner.nextInt();
            System.out.println(n);
        }
    }
    public static void main26(String[] args) {
        Scanner scanner =new Scanner(System.in);
        String str =scanner.nextLine();
        int n = scanner.nextInt();
        double d=scanner.nextDouble();
        scanner.close();
    }
    public static void main25(String[] args) {
        Random random = new Random(); // 默认随机种子是系统时间
        Scanner sc = new Scanner(System.in);
        int toGuess = random.nextInt(100);
        while (true) {
            System.out.println("请输入要输入的数字: (1-100)");
            int num = sc.nextInt();
            if (num < toGuess) {
                System.out.println("低了");
            } else if (num > toGuess) {
                System.out.println("高了");
            } else {
                System.out.println("猜对了");
                break;
            }
        }
        sc.close();
    }

    /**
     * 1、break和continue都必须在循环里【break也可以在switch里】
     * Java里面没有goto，goto目前是保留字，随时有一天可能被启用！
     * @param args
     */

    public static void main24(String[] args) {
        int sum =0;
        for (int i = 1; i <=5; i++) {
            int ret = 1;
            for (int j = 1; j <=i; j++) {
                ret *= j;
            }
            sum += ret;
        }
        System.out.println(sum);
    }
    public static void main23(String[] args) {
        int sum = 0;
        for (int i = 0; i <=100; i++) {
            sum+=i;
        }
        System.out.println(sum);
    }

    public static void main22(String[] args) {
        //找到1~100之间既能被三整除的数字， 也能被5整除的数字
        int i =1;
        while (i<=100){
            if(i% 15 != 0){
                i++;
                continue;
            }
            System.out.println(i);
            i++;
        }

    }
    public static void main21(String[] args) {
        int i= 1;
        while (i<=10){
            if(i%3!=0){
                i++;
                continue;
            }
            System.out.println(i);
            i++;
        }
    }
    public static void main20(String[] args) {
       int j =1;
       int sum =0;
       while (j<=5){
           int i =1;
           int ret =1;
           while (i<=j){
               ret *= i;
               i++;
           }
           sum += ret;
           j++;
       }
        System.out.println(sum);
    }

    public static void main19(String[] args) {
        int sum = 0;
        int i = 1;
        while (i <= 10){
            sum += i;
            i++;
        }
    }
    public static void main18(String[] args) {
        int sum = 0;
        int i = 1;
        while (i <= 10){
            sum += i;
            i++;
        }
        System.out.println(sum);
    }
    // Java当中不能做switch参数的数据类型有哪些？
    //      long float double boolean  JDK1.5开始，引入枚举，也可以作为switch的参数
    public static void main17(String[] args) {
        int a =10;
        switch (a) { // switch 里面的内容不能是复杂的表达式
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
            default:
                System.out.println("参数不匹配");
                break;
        }
    }
    public static void main16(String[] args) {
        Scanner scanner = new Scanner(System.in); //alt+回车自动补全
        int year = scanner.nextInt();
        if((year % 4 ==0 && year % 100!=0) || (year%400==0)){
            System.out.println("是闰年");
        }
        else {
            System.out.println("不是闰年");
        }
        scanner.close(); //关闭资源，不关闭也不会有bug
    }
    public static void main15(String[] args) {
        Scanner scanner = new Scanner(System.in); //alt+回车自动补全
        int n = scanner.nextInt();
        if(n%2 == 0) {
            System.out.println("偶数");
        }
        else {
            System.out.println("奇数");
        }
        /*
            scanner.next();遇到空格读取结束
            scanner.nextLine();遇到空格读取不结束
            这两种都可以读取字符串
         */
    }
    public static void main14(String[] args) {
        //所有的代码都是用逻辑控制实现的   选择结构 循环结构 顺序结构
    }
    public static void main13(String[] args) {
        /**
         *  & 比特位对应位都是1，结果就是1
         *  | 比特位对应位有1，结果就是1
         *  ^ 比特位对应位相同是0，不同是1，本质就是找不同
         *  ~ 比特位按位取反 ，0->1 1->0
         */
    }
    public static void main12(String[] args) {
        //使用关系运算符，其结果就是一个Boolean值
        /**
         * [表达式1 && 表达式2] 这两个表达式全是布尔表达式
         * 支持短路：如果表达式1为假就不执行表达式2了
         * [表达式1 || 表达式2] 这两个表达式也全是布尔表达式
         * 只要一个表达式为真，则整个表达式为真
         * 同样支持短路：如果表达式1为真，就不执行表达式2了
         */
    }
    public static void main11(String[] args) {
        int a = 10;
        System.out.println(a++); //10

        int c =10;
        System.out.println(++c); //11
    }
    public static void main10(String[] args) {
        int a =10;
        a += 1;
        System.out.println(a);

        short s =10;
        //s =(short) (s+9);
        s+=9; //Java会自动进行强制类型转换
        System.out.println(s);
    }
    public static void main9(String[] args) {
        int a =1;
        int b =2;
        System.out.println(a/b);
        //在java里面除数一定不能为0

        // java中比较特殊，可以对小数进行求余数
        System.out.println(11.5 % 2);//1.5
    }
    public static void main8(String[] args) {
        String str= "123";
        int ret = Integer.valueOf(str);
        System.out.println(ret);
    }
    public static void main7(String[] args) {
        int num = 10;
        String ret = String.valueOf(num);
        System.out.println(ret);

        String ret2 =num+"";
        System.out.println(ret2);
    }
    public static void main6(String[] args) {
        byte a = 12; //-128 ~127
        byte b =2;
        //byte c = a+b; //报错 对于cpu来说，小于四个字节的会提升为int类型，整型赋值给byte是不行
        byte c=(byte) (a+b); //所以必须进行强制类型转换
        System.out.println(c);
        byte d=1+2; //这里就不会报错，因为在程序编译的时候，这里就已经被编译为3了


        // 1. 不同类型的数据混合运算, 范围小的会提升成范围大的.
        // 2. 对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算
        // 类型提升是为了效率高

    }
    public static void main5(String[] args) {
        int a =10;
        //boolean b= (boolean) a; //就算强制类型转换也是不能实现的
    }
    public static void main4(String[] args) {
        int a = 10;
        long b = a;
        System.out.println(b);
        long l = 1111111111111111111l;
        int c =(int)l;//强制类型转换
        System.out.println(c);
    }
    public static void main3(String[] args) {
        String str ="hello!";
        System.out.println(str);

        //注意问题：
        System.out.println("hello"+"world"); //+表示拼接
        System.out.println("hello"+10+20);  //其他数据类型和字符串使用+拼接，结果是字符串
        System.out.println("hello"+(10+20)); // hello 30
        System.out.println(10+20+"hello"); //30hello,计算器运算的时候从左往右算

        //转义字符打印双引号
        String s1 = "\"bit\""; //"bit"
        System.out.println(s1);
    }
    public static void main1(String[] args) {
        String str ="hello!";
        System.out.println(str);
    }
    public static void main2(String[] args) {
        System.out.println("hello java!!");
        short s = 10;//2个字节     -2^15~2^15-1
        boolean flg = true;
        System.out.println(flg);
        //在C语言中，0是假，非0是真
        //但是在Java里面，boolean只有两个取值，要么是true要么是false，不能有其他的值
        //在JVM的规范中，没有规定bool类型的大小
    }

    public static void main50(String[] args) {
        int i = 0;
        int j = 0;
        for (i = 1;i <= 100;i++){  //外层循环：负责找到1-100之间的每一个数
            for(j = 2;j < i;j++){  //内层循环：判断"这个数"是否为素数
                if(i % j == 0){    //如果有'一个数'可以被"这个数"整除，则跳出内层循环
                    break;
                }
            }
            if(j == i){            //如果"这个数"就是本身，则为素数
                System.out.print(i + " ");
            }
        }
    }

    /**
     * 水仙花数plus
     * @param n
     */
    public static void findNum(int n){
        for(int i=1;i<=n;i++){
            int count=0;//数字的位数
            int tmp =i;
            while (tmp!=0){
                count++;
                tmp/=10;
            }
            //count已经知道了数字的位数 tmp =0;
            tmp =i;
            int sum=0;
            while (tmp!=0){
                sum+=Math.pow(tmp%10,count);
                tmp /=10;
            }
            if(sum==i){
                System.out.println(i);
            }
        }
    }

    /**
     * 求二进制中有多少个1
     * @param args
     */
    public static int numOfOne(int n){
        int count =0;
        while (n!=0){
            if((n&1)==1){
                count++;
            }
            n = n>>>1;
        }
        return count;
    }
    public static int numOfOnePro(int n) {
        int count =0;
        //每次按位与 都会少一个1，最后等于0的时候，说明一个1都没有了
        while (n!=0){
            count++;
            n=n&(n-1);
        }
        return count;
    }

    /**
     * 获取二级制中的奇数位和偶数位
     * @param args
     */
    public static void printOne(int n){
        for(int i=30;i>=0;i-=2){
            System.out.print(((n>>i)&1)+" ");
        }
        System.out.println();
        for(int i =31;i>=1;i-=2){
            System.out.print(((n>>i)&1)+" ");
        }
    }

    /**
     * 逆序打印整数的每一位
     * @param args
     */
    public static void reversePrint(int n){
        while (n!=0){
            System.out.print(n%10+" ");
            n/=10;
        }
    }

    /**
     * 找出出现一次的数字
     * @param args
     */
    public static void main52(String[] args) {
        int[] array={1,2,3,2,1};
        int sum =array[0];
        for(int i = 1;i<array.length;i++){
            sum = sum ^ array[i];
        }
        System.out.println(sum);
    }
    public static void main51(String[] args) {
        /*Scanner scanner =new Scanner(System.in);
        int n =scanner.nextInt();
        //findNum(n);
        //System.out.println(numOfOne(n));
        System.out.println(numOfOnePro(n));*/
        //printOne(11);
        reversePrint(123);
    }
    /**
     * 使用函数求最大值
     */
    public static int max2(int a,int b){
        return a>b?a:b;
    }
    public static int max3(int a,int b,int c){
        return max2(max2(a,b),c);
    }

    public static void main(String[] args) {
        System.out.println(max3(1,2,3));
    }
    /**
     * 奇数位于偶数之前
     * @param args
     */
    public static void main53(String[] args) {
        int[] array={1,2,3,4,5};
        int left =0;
        int right =array.length-1;
        while (left<right){
            while(left < right && array[left]%2 != 0){
                left++;
            }
            while (left < right && array[right]%2 == 0){
                right--;
            }
            int tmp = array[left];
            array[left] = array[right];
            array[right] =tmp;
        }
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }



}

